立即開始

在腳本中搜尋"the script"

Geo. Geo. This library provides a comprehensive set of geometric functions based on 2 simple types for point and line manipulation, point array calculations, some vector operations (Borrowed from @ricardosantos ), angle calculations, and basic polygon analysis. It offers tools for creating, transforming, and analyzing geometric shapes and their relationships. View the source code for detailed documentation on each function and type. ═════════════════════════════════════════════════════════════════════════ █  OVERVIEW This library enhances TradingView's Pine Script with robust geometric capabilities. It introduces the Point and Line types, along with a suite of functions for various geometric operations. These functionalities empower you to perform advanced calculations, manipulations, and analyses involving points, lines, vectors, angles, and polygons directly within your Pine scripts. The example is at the bottom of the script. ( Commented out ) █  CONCEPTS This library revolves around two fundamental types:  • Point: Represents a point in 2D space with x and y coordinates, along with optional 'a' (angle) and 'v' (value) fields for versatile use. Crucially, for plotting, utilize the `.to_chart_point()` method to convert Points into plottable chart.point objects.  • Line: Defined by a starting Point and a slope , enabling calculations like getting y for a given x, or finding intersection points. █  FEATURES  • Point Manipulation: Perform operations like addition, subtraction, scaling, rotation, normalization, calculating distances, dot products, cross products, midpoints, and more with Point objects.  • Line Operations: Create lines, determine their slope, calculate y from x (and vice versa), and find the intersection points of two lines.  • Vector Operations: Perform vector addition, subtraction, multiplication, division, negation, perpendicular vector calculation, floor, fractional part, sine, absolute value, modulus, sign, round, scaling, rescaling, rotation, and ceiling operations.  • Angle Calculations: Compute angles between points in degrees or radians, including signed, unsigned, and 360-degree angles.  • Polygon Analysis: Calculate the area, perimeter, and centroid of polygons. Check if a point is inside a given polygon and determine the convex hull perimeter.  • Chart Plotting: Conveniently convert Point objects to chart.point objects for plotting lines and points on the chart. The library also includes functions for plotting lines between individual and series of points.  • Utility Functions: Includes helper functions such as square root, square, cosine, sine, tangent, arc cosine, arc sine, arc tangent, atan2, absolute distance, golden ratio tolerance check, fractional part, and safe index/check for chart plotting boundaries. █  HOW TO USE 1 — Include the library in your script using: import kaigouthro/geo/1 2 — Create Point and Line objects: p1 = geo.Point(bar_index, close) p2 = geo.Point(bar_index , open) myLine = geo.Line(p1, geo.slope(p1, p2)) // maybe use that line to detect a crossing for an alert ... hmmm 3 — Utilize the provided functions: distance = geo.distance(p1, p2) intersection = geo.intersection(line1, line2) 4 — For plotting labels, lines, convert Point to chart.point : label.new(p1.to_chart_point(), " Hi ") line.new(p1.to_chart_point(),p2.to_chart_point()) █  NOTES This description provides a concise overview. Consult the library's source code for in-depth documentation, including detailed descriptions, parameter types, and return values for each function and method. The source code is structured with comprehensive comments using the `//@` format for seamless integration with TradingView's auto-documentation features. █  Possibilities.. Library "geo" This library provides a comprehensive set of geometric functions and types, including point and line manipulation, vector operations, angle calculations, and polygon analysis. It offers tools for creating, transforming, and analyzing geometric shapes and their relationships. sqrt(value)   Square root function   Parameters:      value (float) : (float) - The number to take the square root of   Returns: (float) - The square root of the input value sqr(x)   Square function   Parameters:      x (float) : (float) - The number to square   Returns: (float) - The square of the input value cos(v)   Cosine function   Parameters:      v (float) : (series float) - The value to find the cosine of   Returns: (series float) - The cosine of the input value sin(v)   Sine function   Parameters:      v (float) : (series float) - The value to find the sine of   Returns: (series float) - The sine of the input value tan(v)   Tangent function   Parameters:      v (float) : (series float) - The value to find the tangent of   Returns: (series float) - The tangent of the input value acos(v)   Arc cosine function   Parameters:      v (float) : (series float) - The value to find the arc cosine of   Returns: (series float) - The arc cosine of the input value asin(v)   Arc sine function   Parameters:      v (float) : (series float) - The value to find the arc sine of   Returns: (series float) - The arc sine of the input value atan(v)   Arc tangent function   Parameters:      v (float) : (series float) - The value to find the arc tangent of   Returns: (series float) - The arc tangent of the input value atan2(dy, dx)   atan2 function   Parameters:      dy (float) : (float) - The y-coordinate      dx (float) : (float) - The x-coordinate   Returns: (float) - The angle in radians gap(_value1, __value2)   Absolute distance between any two float values   Parameters:      _value1 (float) : First value      __value2 (float)   Returns: Absolute Positive Distance phi_tol(a, b, tolerance)   Check if the ratio is within the tolerance of the golden ratio   Parameters:      a (float) : (float) The first number      b (float) : (float) The second number      tolerance (float) : (float) The tolerance percennt as 1 = 1 percent   Returns: (bool) True if the ratio is within the tolerance, false otherwise frac(x)   frad Fractional   Parameters:      x (float) : (float) - The number to convert to fractional   Returns: (float) - The number converted to fractional safeindex(x, limit)   limiting int to hold the value within the chart range   Parameters:      x (float) : (float) - The number to limit      limit (int)   Returns: (int) - The number limited to the chart range safecheck(x, limit)   limiting int check if within the chartplottable range   Parameters:      x (float) : (float) - The number to limit      limit (int)   Returns: (int) - The number limited to the chart range interpolate(a, b, t)   interpolate between two values   Parameters:      a (float) : (float) - The first value      b (float) : (float) - The second value      t (float) : (float) - The interpolation factor (0 to 1)   Returns: (float) - The interpolated value gcd(_numerator, _denominator)   Greatest common divisor of two integers   Parameters:      _numerator (int)      _denominator (int)   Returns: (int) The greatest common divisor method set_x(self, value)   Set the x value of the point, and pass point for chaining   Namespace types: Point   Parameters:      self (Point) : (Point) The point to modify      value (float) : (float) The new x-coordinate method set_y(self, value)   Set the y value of the point, and pass point for chaining   Namespace types: Point   Parameters:      self (Point) : (Point) The point to modify      value (float) : (float) The new y-coordinate method get_x(self)   Get the x value of the point   Namespace types: Point   Parameters:      self (Point) : (Point) The point to get the x-coordinate from   Returns: (float) The x-coordinate method get_y(self)   Get the y value of the point   Namespace types: Point   Parameters:      self (Point) : (Point) The point to get the y-coordinate from   Returns: (float) The y-coordinate method vmin(self)   Lowest element of the point   Namespace types: Point   Parameters:      self (Point) : (Point) The point   Returns: (float) The lowest value between x and y method vmax(self)   Highest element of the point   Namespace types: Point   Parameters:      self (Point) : (Point) The point   Returns: (float) The highest value between x and y method add(p1, p2)   Addition   Namespace types: Point   Parameters:      p1 (Point) : (Point) - The first point      p2 (Point) : (Point) - The second point   Returns: (Point) - the add of the two points method sub(p1, p2)   Subtraction   Namespace types: Point   Parameters:      p1 (Point) : (Point) - The first point      p2 (Point) : (Point) - The second point   Returns: (Point) - the sub of the two points method mul(p, scalar)   Multiplication by scalar   Namespace types: Point   Parameters:      p (Point) : (Point) - The point      scalar (float) : (float) - The scalar to multiply by   Returns: (Point) - the multiplied point of the point and the scalar method div(p, scalar)   Division by scalar   Namespace types: Point   Parameters:      p (Point) : (Point) - The point      scalar (float) : (float) - The scalar to divide by   Returns: (Point) - the divided point of the point and the scalar method rotate(p, angle)   Rotate a point around the origin by an angle (in degrees)   Namespace types: Point   Parameters:      p (Point) : (Point) - The point to rotate      angle (float) : (float) - The angle to rotate by in degrees   Returns: (Point) - the rotated point method length(p)   Length of the vector from origin to the point   Namespace types: Point   Parameters:      p (Point) : (Point) - The point   Returns: (float) - the length of the point method length_squared(p)   Length squared of the vector   Namespace types: Point   Parameters:      p (Point) : (Point) The point   Returns: (float) The squared length of the point method normalize(p)   Normalize the point to a unit vector   Namespace types: Point   Parameters:      p (Point) : (Point) - The point to normalize   Returns: (Point) - the normalized point method dot(p1, p2)   Dot product   Namespace types: Point   Parameters:      p1 (Point) : (Point) - The first point      p2 (Point) : (Point) - The second point   Returns: (float) - the dot of the two points method cross(p1, p2)   Cross product result (in 2D, this is a scalar)   Namespace types: Point   Parameters:      p1 (Point) : (Point) - The first point      p2 (Point) : (Point) - The second point   Returns: (float) - the cross of the two points method distance(p1, p2)   Distance between two points   Namespace types: Point   Parameters:      p1 (Point) : (Point) - The first point      p2 (Point) : (Point) - The second point   Returns: (float) - the distance of the two points method Point(x, y, a, v)   Point Create Convenience   Namespace types: series float, simple float, input float, const float   Parameters:      x (float)      y (float)      a (float)      v (float)   Returns: (Point) new point method angle(p1, p2)   Angle between two points in degrees   Namespace types: Point   Parameters:      p1 (Point) : (Point) - The first point      p2 (Point) : (Point) - The second point   Returns: (float) - the angle of the first point and the second point method angle_between(p, pivot, other)   Angle between two points in degrees from a pivot point   Namespace types: Point   Parameters:      p (Point) : (Point) - The point to calculate the angle from      pivot (Point) : (Point) - The pivot point      other (Point) : (Point) - The other point   Returns: (float) - the angle between the two points method translate(p, from_origin, to_origin)   Translate a point from one origin to another   Namespace types: Point   Parameters:      p (Point) : (Point) - The point to translate      from_origin (Point) : (Point) - The origin to translate from      to_origin (Point) : (Point) - The origin to translate to   Returns: (Point) - the translated point method midpoint(p1, p2)   Midpoint of two points   Namespace types: Point   Parameters:      p1 (Point) : (Point) - The first point      p2 (Point) : (Point) - The second point   Returns: (Point) - The midpoint of the two points method rotate_around(p, angle, pivot)   Rotate a point around a pivot point by an angle (in degrees)   Namespace types: Point   Parameters:      p (Point) : (Point) - The point to rotate      angle (float) : (float) - The angle to rotate by in degrees      pivot (Point) : (Point) - The pivot point to rotate around   Returns: (Point) - the rotated point method multiply(_a, _b)   Multiply vector _a with _b   Namespace types: Point   Parameters:      _a (Point) : (Point) The first point      _b (Point) : (Point) The second point   Returns: (Point) The result of the multiplication method divide(_a, _b)   Divide vector _a by _b   Namespace types: Point   Parameters:      _a (Point) : (Point) The first point      _b (Point) : (Point) The second point   Returns: (Point) The result of the division method negate(_a)   Negative of vector _a   Namespace types: Point   Parameters:      _a (Point) : (Point) The point to negate   Returns: (Point) The negated point method perp(_a)   Perpendicular Vector of _a   Namespace types: Point   Parameters:      _a (Point) : (Point) The point   Returns: (Point) The perpendicular point method vfloor(_a)   Compute the floor of argument vector _a   Namespace types: Point   Parameters:      _a (Point) : (Point) The point   Returns: (Point) The floor of the point method fractional(_a)   Compute the fractional part of the elements from vector _a   Namespace types: Point   Parameters:      _a (Point) : (Point) The point   Returns: (Point) The fractional part of the point method vsin(_a)   Compute the sine of argument vector _a   Namespace types: Point   Parameters:      _a (Point) : (Point) The point   Returns: (Point) The sine of the point lcm(a, b)   Least common multiple of two integers   Parameters:      a (int) : (int) The first integer      b (int) : (int) The second integer   Returns: (int) The least common multiple method vabs(_a)   Compute the absolute of argument vector _a   Namespace types: Point   Parameters:      _a (Point) : (Point) The point   Returns: (Point) The absolute of the point method vmod(_a, _b)   Compute the mod of argument vector _a   Namespace types: Point   Parameters:      _a (Point) : (Point) The point      _b (float) : (float) The mod   Returns: (Point) The mod of the point method vsign(_a)   Compute the sign of argument vector _a   Namespace types: Point   Parameters:      _a (Point) : (Point) The point   Returns: (Point) The sign of the point method vround(_a)   Compute the round of argument vector _a   Namespace types: Point   Parameters:      _a (Point) : (Point) The point   Returns: (Point) The round of the point method normalize_y(p, height)   normalizes the y value of a point to an input height   Namespace types: Point   Parameters:      p (Point) : (Point) - The point to normalize      height (float) : (float) - The height to normalize to   Returns: (Point) - the normalized point centroid(points)   Calculate the centroid of multiple points   Parameters:      points (array) : (array) The array of points   Returns: (Point) The centroid point random_point(_height, _width, _origin, _centered)   Random Point in a given height and width   Parameters:      _height (float) : (float) The height of the area to generate the point in      _width (float) : (float) The width of the area to generate the point in      _origin (Point) : (Point) The origin of the area to generate the point in (default: na, will create a Point(0, 0))      _centered (bool) : (bool) Center the origin point in the area, otherwise, positive h/w (default: false)   Returns: (Point) The random point in the given area random_point_array(_origin, _height, _width, _centered, _count)   Random Point Array in a given height and width   Parameters:      _origin (Point) : (Point) The origin of the area to generate the array (default: na, will create a Point(0, 0))      _height (float) : (float) The height of the area to generate the array      _width (float) : (float) The width of the area to generate the array      _centered (bool) : (bool) Center the origin point in the area, otherwise, positive h/w (default: false)      _count (int) : (int) The number of points to generate (default: 50)   Returns: (array) The random point array in the given area method sort_points(points, by_x)   Sorts an array of points by x or y coordinate   Namespace types: array   Parameters:      points (array) : (array) The array of points to sort      by_x (bool) : (bool) Whether to sort by x-coordinate (true) or y-coordinate (false)   Returns: (array) The sorted array of points method equals(_a, _b)   Compares two points for equality   Namespace types: Point   Parameters:      _a (Point) : (Point) The first point      _b (Point) : (Point) The second point   Returns: (bool) True if the points are equal, false otherwise method max(origin, _a, _b)   Maximum of two points from origin, using dot product   Namespace types: Point   Parameters:      origin (Point)      _a (Point) : (Point) The first point      _b (Point) : (Point) The second point   Returns: (Point) The maximum point method min(origin, _a, _b)   Minimum of two points from origin, using dot product   Namespace types: Point   Parameters:      origin (Point)      _a (Point) : (Point) The first point      _b (Point) : (Point) The second point   Returns: (Point) The minimum point method avg_x(points)   Average x of point array   Namespace types: array   Parameters:      points (array) : (array) The array of points   Returns: (float) The average x-coordinate method avg_y(points)   Average y of point array   Namespace types: array   Parameters:      points (array) : (array) The array of points   Returns: (float) The average y-coordinate method range_x(points)   Range of x values in point array   Namespace types: array   Parameters:      points (array) : (array) The array of points   Returns: (float) The range of x-coordinates method range_y(points)   Range of y values in point array   Namespace types: array   Parameters:      points (array) : (array) The array of points   Returns: (float) The range of y-coordinates method max_x(points)   max of x values in point array   Namespace types: array   Parameters:      points (array) : (array) The array of points   Returns: (float) The max of x-coordinates method min_y(points)   min of x values in point array   Namespace types: array   Parameters:      points (array) : (array) The array of points   Returns: (float) The min of x-coordinates method scale(_a, _scalar)   Scale a point by a scalar   Namespace types: Point   Parameters:      _a (Point) : (Point) The point to scale      _scalar (float) : (float) The scalar value   Returns: (Point) The scaled point method rescale(_a, _length)   Rescale a point to a new magnitude   Namespace types: Point   Parameters:      _a (Point) : (Point) The point to rescale      _length (float) : (float) The new magnitude   Returns: (Point) The rescaled point method rotate_rad(_a, _radians)   Rotate a point by an angle in radians   Namespace types: Point   Parameters:      _a (Point) : (Point) The point to rotate      _radians (float) : (float) The angle in radians   Returns: (Point) The rotated point method rotate_degree(_a, _degree)   Rotate a point by an angle in degrees   Namespace types: Point   Parameters:      _a (Point) : (Point) The point to rotate      _degree (float) : (float) The angle in degrees   Returns: (Point) The rotated point method vceil(_a, _digits)   Ceil a point to a certain number of digits   Namespace types: Point   Parameters:      _a (Point) : (Point) The point to ceil      _digits (int) : (int) The number of digits to ceil to   Returns: (Point) The ceiled point method vpow(_a, _exponent)   Raise both point elements to a power   Namespace types: Point   Parameters:      _a (Point) : (Point) The point      _exponent (float) : (float) The exponent   Returns: (Point) The point with elements raised to the power method perpendicular_distance(_a, _b, _c)   Distance from point _a to line between _b and _c   Namespace types: Point   Parameters:      _a (Point) : (Point) The point      _b (Point) : (Point) The start point of the line      _c (Point) : (Point) The end point of the line   Returns: (float) The perpendicular distance method project(_a, _axis)   Project a point onto another   Namespace types: Point   Parameters:      _a (Point) : (Point) The point to project      _axis (Point) : (Point) The point to project onto   Returns: (Point) The projected point method projectN(_a, _axis)   Project a point onto a point of unit length   Namespace types: Point   Parameters:      _a (Point) : (Point) The point to project      _axis (Point) : (Point) The unit length point to project onto   Returns: (Point) The projected point method reflect(_a, _axis)   Reflect a point on another   Namespace types: Point   Parameters:      _a (Point) : (Point) The point to reflect      _axis (Point) : (Point) The point to reflect on   Returns: (Point) The reflected point method reflectN(_a, _axis)   Reflect a point to an arbitrary axis   Namespace types: Point   Parameters:      _a (Point) : (Point) The point to reflect      _axis (Point) : (Point) The axis to reflect to   Returns: (Point) The reflected point method angle_rad(_a)   Angle in radians of a point   Namespace types: Point   Parameters:      _a (Point) : (Point) The point   Returns: (float) The angle in radians method angle_unsigned(_a, _b)   Unsigned degree angle between 0 and +180 by given two points   Namespace types: Point   Parameters:      _a (Point) : (Point) The first point      _b (Point) : (Point) The second point   Returns: (float) The unsigned angle in degrees method angle_signed(_a, _b)   Signed degree angle between -180 and +180 by given two points   Namespace types: Point   Parameters:      _a (Point) : (Point) The first point      _b (Point) : (Point) The second point   Returns: (float) The signed angle in degrees method angle_360(_a, _b)   Degree angle between 0 and 360 by given two points   Namespace types: Point   Parameters:      _a (Point) : (Point) The first point      _b (Point) : (Point) The second point   Returns: (float) The angle in degrees (0-360) method clamp(_a, _vmin, _vmax)   Restricts a point between a min and max value   Namespace types: Point   Parameters:      _a (Point) : (Point) The point to restrict      _vmin (Point) : (Point) The minimum point      _vmax (Point) : (Point) The maximum point   Returns: (Point) The restricted point method lerp(_a, _b, _rate_of_move)   Linearly interpolates between points a and b by _rate_of_move   Namespace types: Point   Parameters:      _a (Point) : (Point) The starting point      _b (Point) : (Point) The ending point      _rate_of_move (float) : (float) The rate of movement (0-1)   Returns: (Point) The interpolated point method slope(p1, p2)   Slope of a line between two points   Namespace types: Point   Parameters:      p1 (Point) : (Point) - The first point      p2 (Point) : (Point) - The second point   Returns: (float) - The slope of the line method gety(self, x)   Get y-coordinate of a point on the line given its x-coordinate   Namespace types: Line   Parameters:      self (Line) : (Line) - The line      x (float) : (float) - The x-coordinate   Returns: (float) - The y-coordinate method getx(self, y)   Get x-coordinate of a point on the line given its y-coordinate   Namespace types: Line   Parameters:      self (Line) : (Line) - The line      y (float) : (float) - The y-coordinate   Returns: (float) - The x-coordinate method intersection(self, other)   Intersection point of two lines   Namespace types: Line   Parameters:      self (Line) : (Line) - The first line      other (Line) : (Line) - The second line   Returns: (Point) - The intersection point method calculate_arc_point(self, b, p3)   Calculate a point on the arc defined by three points   Namespace types: Point   Parameters:      self (Point) : (Point) The starting point of the arc      b (Point) : (Point) The middle point of the arc      p3 (Point) : (Point) The end point of the arc   Returns: (Point) A point on the arc approximate_center(point1, point2, point3)   Approximate the center of a spiral using three points   Parameters:      point1 (Point) : (Point) The first point      point2 (Point) : (Point) The second point      point3 (Point) : (Point) The third point   Returns: (Point) The approximate center point createEdge(center, radius, angle)   Get coordinate from center by radius and angle   Parameters:      center (Point) : (Point) - The center point      radius (float) : (float) - The radius of the circle      angle (float) : (float) - The angle in degrees   Returns: (Point) - The coordinate on the circle getGrowthFactor(p1, p2, p3)   Get growth factor of spiral point   Parameters:      p1 (Point) : (Point) - The first point      p2 (Point) : (Point) - The second point      p3 (Point) : (Point) - The third point   Returns: (float) - The growth factor method to_chart_point(point)   Convert Point to chart.point using chart.point.from_index(safeindex(point.x), point.y)   Namespace types: Point   Parameters:      point (Point) : (Point) - The point to convert   Returns: (chart.point) - The chart.point representation of the input point method plotline(p1, p2, col, width)   Draw a line from p1 to p2   Namespace types: Point   Parameters:      p1 (Point) : (Point) First point      p2 (Point) : (Point) Second point      col (color)      width (int)   Returns: (line) Line object method drawlines(points, col, ignore_boundary)   Draw lines between points in an array   Namespace types: array   Parameters:      points (array) : (array) The array of points      col (color) : (color) The color of the lines      ignore_boundary (bool) : (bool) The color of the lines method to_chart_points(points)   Draw an array of points as chart points on the chart with line.new(chartpoint1, chartpoint2, color=linecolor)   Namespace types: array   Parameters:      points (array) : (array) - The points to draw   Returns: (array) The array of chart points polygon_area(points)   Calculate the area of a polygon defined by an array of points   Parameters:      points (array) : (array) The array of points representing the polygon vertices   Returns: (float) The area of the polygon polygon_perimeter(points)   Calculate the perimeter of a polygon   Parameters:      points (array) : (array) Array of points defining the polygon   Returns: (float) Perimeter of the polygon is_point_in_polygon(point, _polygon)   Check if a point is inside a polygon   Parameters:      point (Point) : (Point) The point to check      _polygon (array)   Returns: (bool) True if the point is inside the polygon, false otherwise method perimeter(points)   Calculates the convex hull perimeter of a set of points   Namespace types: array   Parameters:      points (array) : (array) The array of points   Returns: (array) The array of points forming the convex hull perimeter Point   A Point, can be used for vector, floating calcs, etc. Use the cp method for plots   Fields:      x (series float) : (float) The x-coordinate      y (series float) : (float) The y-coordinate      a (series float) : (float) An Angle storage spot      v (series float) : (float) A Value Line   Line   Fields:      point (Point) : (Point) The starting point of the line      slope (series float) : (float) The slope of the line GOMTRY.
Pine Script®腳本庫
由kaigouthro提供
5
Pure Price Action Liquidity Sweeps [LuxAlgo]The Pure Price Action Liquidity Sweeps indicator is a pure price action adaptation of our previously published and highly popular Liquidity-Sweeps script. Similar to its earlier version, this indicator detects the presence of liquidity sweeps on the user's chart, while also identifying potential areas of support/resistance or entry when liquidity levels are taken. The key difference, however, is that this price action version relies solely on price patterns, eliminating the need for numerical swing length settings. 🔶 USAGE A Liquidity Sweep occurs when the price breaks through a liquidity level , after which the price returns below/above the liquidity level , forming a wick. The examples below show a bullish and bearish scenario of "a wick passing through a liquidity level where the price quickly comes back". Short-term liquidity sweep detection is based on short-term swing levels. Some of these short-term levels, depending on further market developments, may evolve into intermediate-term levels and, in the long run, become long-term levels. Therefore, enabling short-term detection with the script means showing all levels, including minor and temporal ones. Depending on the trader's style, some of these levels may be considered noise. Enabling intermediate and long-term levels can help filter out this noise and provide more significant levels for trading decisions. For further details on how swing levels are identified please refer to the details section. The Intermediate-term option selection for the same chart as above, filters out minor or noisy levels, providing clearer and more significant levels for traders to observe. 🔶 DETAILS The swing points detection feature relies exclusively on price action, eliminating the need for numerical user-defined settings. The first step involves detecting short-term swing points, where a short-term swing high (STH) is identified as a price peak surrounded by lower highs on both sides. Similarly, a short-term swing low is recognized as a price trough surrounded by higher lows on both sides. Intermediate-term swing and long-term swing points are detected using the same approach but with a slight modification. Instead of directly analyzing price candles, we now utilize the previously detected short-term swing points. For intermediate-term swing points, we rely on short-term swing points, while for long-term swing points, we use the intermediate-term ones. 🔶 SETTINGS Detection: Period options of the detected swing points. 🔶 RELATED SCRIPTS Pure-Price-Action-Structures. Liquidity-Sweeps.
Pine Script®指標
由LuxAlgo提供
7
[EVI]EMA with Volume LevelsThe " EMA with Volume Levels" script calculates the Exponential Moving Average (EMA) of the closing prices over a specified period and dynamically changes the color of the EMA based on volume levels. This indicator helps traders easily identify the current volume conditions. As the volume increases or decreases, the color of the EMA changes, providing a visual cue that can assist in making better trading decisions. Features This script offers the following features: EMA Calculation: Calculates the Exponential Moving Average of the closing prices over the user-defined period (default is 360). Volume Threshold Calculation: Computes the Simple Moving Average (SMA) and standard deviation of the volume over the user-defined period (default is 500), classifying the volume levels into extreme, high, medium, and low. Dynamic EMA Color: Changes the color of the EMA dynamically based on volume levels, displaying it visually on the chart. Chart Interpretation EMA Color and Volume: If the EMA line is red, it indicates very high volume. If the EMA line is green, it indicates high volume. If the EMA line is light green, it indicates medium volume. If the EMA line is gray, it indicates low volume. If the EMA line is dark gray, it indicates very low volume. Cross Analysis: When the EMA line and the candles are about to cross, and the volume is high (causing the EMA line to turn red), the candles are more likely to break through the 360-day EMA line. Conversely, if the volume is low and the EMA line turns dark, the EMA line will likely act as a resistance or support level, increasing the likelihood of a bounce. Additional Indicator: Using the 20-day moving average along with this script can be beneficial. Combining these two moving averages can provide a more comprehensive view of market volatility. Notes Clean Chart: Ensure your chart is clean when using this script. Avoid including other scripts or unnecessary elements. Additional Explanation: If further explanation is needed on how to use or understand the script, you can use drawings or images on the chart to provide additional context.
Pine Script®指標
由rotax380提供
2
Rolling MACDThis indicator displays a Rolling Moving Average Convergence Divergence . Contrary to MACD indicators which use a fix time segment, RMACD calculates using a moving window defined by a time period (not a simple number of bars), so it shows better results. This indicator is inspired by and use the Close & Inventory Bar Retracement Price Line to create an MACD in different timeframes. █  CONCEPTS If you are not already familiar with ​MACD, so look at Help Center will get you started www.tradingview.com The typical MACD, short for moving average convergence/divergence, is a trading indicator used in technical analysis of stock prices, created by Gerald Appel in the late 1970s. It is designed to reveal changes in the strength, direction, momentum, and duration of a trend in a stock's price. The MACD indicator(or "oscillator") is a collection of three time series calculated from historical price data, most often the closing price. These three series are: the MACD series proper, the "signal" or "average" series, and the "divergence" series which is the difference between the two. The MACD series is the difference between a "fast" (short period) exponential moving average (EMA), and a "slow" (longer period) EMA of the price series. The average series is an EMA of the MACD series itself. Because RMACD uses a moving window, it does not exhibit the jumpiness of MACD plots. You can see the more jagged MACD on the chart above. I think both can be useful to traders; up to you to decide which flavor works for you. █  HOW TO USE IT Load the indicator on an active chart (see the Help Center if you don't know how). Time period By default, the script uses an auto-stepping mechanism to adjust the time period of its moving window to the chart's timeframe. The following table shows chart timeframes and the corresponding time period used by the script. When the chart's timeframe is less than or equal to the timeframe in the first column, the second column's time period is used to calculate RMACD: Chart Time timeframe period 1min 🠆 1H 5min 🠆 4H 1H 🠆 1D 4H 🠆 3D 12H 🠆 1W 1D 🠆 1M 1W 🠆 ​3M You can use the script's inputs to specify a fixed time period, which you can express in any combination of days, hours and minutes. By default, the time period currently used is displayed in the lower-right corner of the chart. The script's inputs allow you to hide the display or change its size and location. Minimum Window Size This input field determines the minimum number of values to keep in the moving window, even if these values are outside the prescribed time period. This mitigates situations where a large time gap between two bars would cause the time window to be empty, which can occur in non-24x7 markets where large time gaps may separate contiguous chart bars, namely across holidays or trading sessions. For example, if you were using a 1D time period and there is a two-day gap between two bars, then no chart bars would fit in the moving window after the gap. The default value is 10 bars. // This indicator should make trading easier and improve analysis. Nothing is worse than indicators that give confusingly different signals. I hope you enjoy my new ideas best regards Chervolino
Pine Script®指標
由chervolino提供
MTFT Actionable Signal Targets, TheStrat Suite (4of5)Multi Time Frame Tools Multi Time Frame Tools (MTFT) is a suite of scripts aimed to establish a standard timeframe-based color scheme. This can be utilized to overlay different timeframes calculations/values over a single timeframe. As one example, this would allow to observe the 5-month moving average, 5-week moving average, and 5-day moving average overlaid over each other. This would allow to study a chart, get accustomed to the color scheme and study all these at the same time much easier. All indicators calculated using the below specific timeframes as input, will always use the color scheme outlined below. This is to get you in habit of recognizing the different timeframes overlaid in top of each other. These can be personalized. Longer TF analysis. Yearly - Black Semi-Annual - Yellow Quarterly - White Monthly - Maroon Weekly - Royal Blue Daily - Lime Shorter TF analysis. 4 hour - Fuchsia 1 hour - Orange 30 min - Red 15 min - Brown 10 min - Purple 5 min - Lilac All color coordination is able to be modified in either the “Inputs” or “Style” section. If you need to make changes, make sure to select “Save as Default” on the bottom right of the settings menu. Recommended Chart Color Layout I played around with color coordination a lot. The final product was what worked best for me. I personally use the following chart settings to accent all available TF colors. -> Click on the settings wheel on your chart. -> Click on “Appearance”. Background - Solid -> On the top row pick the 6th color from the left. Vert Grid Lines and Horz Grid Lines -> On the top row pick the 7th color from the left. You may of course change these and the indicator line colors as you like. Adding indicator to Chart -> Open the TradingView “Indicators & Strategies” library, the icon has “ƒx”. -> All premium scripts will be located under “Invite-Only Scripts” -> Click indicator to add to your chart. MTFT TheStrat Suite (5 Scripts) Rob Smith is the creator of ‘TheStrat’ trading strategy. For ‘TheStrat’ I have put together a suite of 5 premium scripts that combined will offer people interested in learning ‘TheStrat’ a cleaner learning process. For 2 of the 5 scripts specifically, the MTFT approach of overlaying multiple longer timeframes(TF) over a shorter TF selected as a display cannot be utilized. The other 2 scripts will have full MTFT functionality and they are my personal favorite. I will be providing very basic info to utilize this script; it is up to you to dive deep into learning this strategy. I am not an expert with the tool or a financial advisor. As with all aspects of life, I recommend you research, learn, discern and practice extensively in order to become a master. 1. MTFT Patterns Pro/Noob 2. MTFT Full Time Frame Continuity Table 3. MTFT Last HML wOpen *4. MTFT Actionable Signal Targets 5. MTFT Reversal Lines MTFT Actionable Signal Targets, TheStrat Suite (4of5) Plots the previous highs/lows for the selected timeframe. Will not plot the high/low for a candlestick that is still active/open. You will have to manually Enable/Disable the high/low depending on the type of actionable signal that you are observing. Previous high/low lines will start from the near exact time that it opened so you can see exactly from what previous candlestick you are tracking each target. Features includes: 1. Six Different Timeframes per script instance. Example below shows a weekly timeframe selected with a Shooting Star as the actionable signal that is being considered along with the past 3 lows for the Week timeframe being enabled. These would be your targets if you were to enter this SHORT trade. Keep in mind that every new week that opens the script will update to the newest 3 lows so if you are still inside a trade you might have to increase the number of past lines in order to keep an eye on the original targets. Which is why I selected 3 in this example, even if there is only 2 targets in mind. The script will allow you to observe how price moves after an actionable signal is triggered and as it approaches the targets on smaller timeframes. Here is the setup from above on a daily timeframe selected showing how priced moved to the targets. This is all based on Robs teachings, but broken down to better grasp how price moves between pivots. 2. 20 different TF to pick from per slot. Timeframes(TF) include: Yearly(Y), Semi-annually(S), Quarterly(Q), Monthly(M), 2-Week(2W), Weekly(W), 3-Day(3D), Daily(D), 12 hour, 8 hour, 6 hour, 4 hour, 3 hour, 2 hour, 1 hour, 30 min, 15 min, 10 min, 5 min. NOTICE: 2W, 3D, 2D, 12h, 8h, 6h, 3h, and 2h don’t have a supported color scheme as I do not personally use them. They are available to pick from in the timeframe selection and you can set a color for these timeframes under the “Unsupported Color Scheme” section in the settings menu for the script if you would like to use them. 3. Show exact price at the pivots. Since drawing lines vs plots doesn’t show the value in the price bar on the right side this setting will show the value of the targets. Image below shows an example of how this looks. 4. Auto-hide timeframes based on specific timeframes selected. For this script, I look for timeframes smaller than the selected timeframe and auto hide these. This applies to all timeframes. For example, in the above Weekly Shooting Star example. If I were to select the monthly timeframe it would hide this timeframe selected so would not show the weekly targets. In the higher timeframes these targets are irrelevant. IMPORTANT NOTE: One of the lessons I would consider most important in attaining clarity regarding trading, is “TheStrat” by Rob Smith. His lesson on “actionable signals” is something that can be applied to any strategy. For this reason, I am including “MTFT TheStrat Patterns Pro” script in all images that will depict confluence for a better trade selection. Example using TheStrat Pro MTFT with this indicator. Look for a “TheStrat actionable signal” or a “TheStrat Reversal signal” on a smaller timeframe that has an instance of this indicator on a larger timeframe calculation that is in range of the candlestick that formed your actionable signal. This means that the indicators plot you are observing must be above the low and below the high of the candlestick that is the actionable signal/reversal signal. Image below shows what this would look like with this indicator. The Image below shows what this would look like with this indicator. The selected timeframe is the Weekly, it shows an ‘S’ char above which is an indication of a Shooting Star Actionable signal and the low from 4 months ago in range showing some potential resistance. This actionable signal is meant to be played for SHORTS. If the low is breached than you would enter a short. For targets you would look at the previous pivots, for this example all targets were hit. This wont always play out so nice and clean, but given that there is so many stocks and so many signals this is just a thought to improve the quality of the signal as it has extra confluence.
Pine Script®指標
由Multi_TF_Tools提供
KISS BOT (Keep It Simple BOT)A very simple script that can be used for Futures and Options Trading - for stocks, crypto, forex etc. The script includes usage of following public scripts: 1. Super Trend 2. Linear Regression 3. Exponential Moving Average Concept, we are using three EMA, with source High, Low, and Close. We want to buy or sell when there is a crossover of third EMA (fastest) over first and second respectively. E.g. the default values are EMA 13 High, EMA 13 Low and EMA 5 Close, we will get Buy signal when EMA 5 crosses over EMA 13 High and we will get Sell signal when EMA 5 crosses under EMA 13 Low. Super Trend settings are made for Looking for Buy or Looking Sell, so that we focus on the trend. Trend is your friend. Buy Trigger Line and Sell Trigger Line are just indication of using Trigger Line, buy is when EMA 5 crosses EMA 13 Low and Sell When EMA 5 Crosses EMA 13 High The Tunnel or Band highlighted is the no trade zone for us and we do not want to trade side ways market. Inside Bars are shown in Yellow, these candles do not qualify for any trade decision. Outside Bars are shown in Pink, these candles do not qualify for any trade decision
Pine Script®指標
由Falcon_Trader_1提供
11
Trendline Pairs (Deep Search)After getting good response on Wedge-and-Flag-Finder-Multi-zigzag , I thought I will build little bit further into the script. Main differences Uses deep search algorithm for patterns instead of just using last 5 pivots Flag pattern is removed so that we can concentrate mainly on trend line pairs More number of overall patterns. Trend Patterns Included Channel - Rising, Falling, Ranging Wedge - Rising, Falling + Expanding, Contracting types Triangle - Expanding, Contracting Indeterminate - Happens in rare cases where angle calculation results in error. It may still belong to one of the above patterns. Please note: This is published as free to use but protected source code indicator. This is because the script contains deep search algorithm which isn't made public yet and is also been used in other invite only scripts. Will not be adding alerts to this indicator.
Pine Script®指標
由Trendoscope提供
72
Swing Assassin's Consolidated ScriptI put this script together to essentially consolidate a number of scripts that I use on a daily basis into one script. This is an ongoing improvement effort, so there may be some garbage in here right now so keep that in mind if you intend to use this to help in your trading. There are 5 moving averages (Hull). I use the Fast, Mid and Slow to find entries after I us the Medium Slow and Super Slow to identify a trend. Otherwise, I have those three turned off. This script also uses Bollinger Bands which I literally cannot trade without. The script also has anchored VWAP , automated support/resistance lines, and a homebrewed Volume Profile that is a copy from Ildar Akhmetgaleev's indicator "Poor Man's Volume Profile" used under Mozilla Public License Version 2.0.
Pine Script®指標
由UnknownUnicorn16914442提供
3
benchLibrary "bench" A simple banchmark library to analyse script performance and bottlenecks. Very useful if you are developing an overly complex application in Pine Script, or trying to optimise a library / function / algorithm... Supports artificial looping benchmarks (of fast functions) Supports integrated linear benchmarks (of expensive scripts) One important thing to note is that the Pine Script compiler will completely ignore any calculations that do not eventually produce chart output. Therefore, if you are performing an artificial benchmark you will need to use the bench.reference(value) function to ensure the calculations are executed. Please check the examples towards the bottom of the script. Quick Reference (Be warned this uses non-standard space characters to get the line indentation to work in the description!) ``` // Looping benchmark style benchmark = bench.new(samples = 500, loops = 5000) data = array.new_int() if bench.start(benchmark)   while bench.loop(benchmark)     array.unshift(data, timenow)   bench.mark(benchmark)   while bench.loop(benchmark)     array.unshift(data, timenow)   bench.mark(benchmark)   while bench.loop(benchmark)     array.unshift(data, timenow)   bench.stop(benchmark)   bench.reference(array.get(data, 0)) bench.report(benchmark, '1x array.unshift()') // Linear benchmark style benchmark = bench.new() data = array.new_int() bench.start(benchmark) for i = 0 to 1000   array.unshift(data, timenow) bench.mark(benchmark) for i = 0 to 1000   array.unshift(data, timenow) bench.stop(benchmark) bench.reference(array.get(data, 0)) bench.report(benchmark,'1000x array.unshift()') ``` Detailed Interface new(samples, loops) Initialises a new benchmark array   Parameters:      samples : int, the number of bars in which to collect samples      loops : int, the number of loops to execute within each sample   Returns: int , the benchmark array active(benchmark) Determing if the benchmarks state is active   Parameters:      benchmark : int , the benchmark array   Returns: bool, true only if the state is active start(benchmark) Start recording a benchmark from this point   Parameters:      benchmark : int , the benchmark array   Returns: bool, true only if the benchmark is unfinished loop(benchmark) Returns true until call count exceeds bench.new(loop) variable   Parameters:      benchmark : int , the benchmark array   Returns: bool, true while looping reference(number, string) Add a compiler reference to the chart so the calculations don't get optimised away   Parameters:      number : float, a numeric value to reference      string : string, a string value to reference mark(benchmark, number, string) Marks the end of one recorded interval and the start of the next   Parameters:      benchmark : int , the benchmark array      number : float, a numeric value to reference      string : string, a string value to reference stop(benchmark, number, string) Stop the benchmark, ending the final interval   Parameters:      benchmark : int , the benchmark array      number : float, a numeric value to reference      string : string, a string value to reference report(Prints, benchmark, title, text_size, position)   Parameters:      Prints : the benchmarks results to the screen      benchmark : int , the benchmark array      title : string, add a custom title to the report      text_size : string, the text size of the log console (global size vars)      position : string, the position of the log console (global position vars) unittest_bench(case) Cache module unit tests, for inclusion in parent script test suite. Usage: bench.unittest_bench(__ASSERTS)   Parameters:      case : string , the current test case and array of previous unit tests (__ASSERTS) unittest(verbose) Run the bench module unit tests as a stand alone. Usage: bench.unittest()   Parameters:      verbose : bool, optionally disable the full report to only display failures
Pine Script®腳本庫
由GeoffHammond提供
13
Relative Volume (rVol), Better Volume, Average Volume ComparisonThis is the best version of relative volume you can find a claim which is based on the logical soundness of its calculation. I have amalgamated various volume analysis into one synergistic script. I wasn't going to opensource it. But, as one of the lucky few winners of TradingClue 2. I felt obligated to give something back to the community. Relative volume traditionally compares current volume to prior bar volume or SMA of volume. This has drawbacks. The question of relative volume is "Volume relative to what?" In the traditional scripts you'll find it displays current volume relative to the last number of bars. But, is that the best way to compare volume. On a daily chart, possibly. On a daily chart this can work because your units of time are uniform. Each day represents a full cycle of volume. However, on an intraday chart? Not so much. Example: If you have a lookback of 9 on an hourly chart in a 24 hour market, you are then comparing the average volume from Midnight - 9 AM to the 9 AM volume. What do you think you'll find? Well at 9:30 when NY exchanges open the volume should be consistently and predictably higher. But though rVol is high relative to the lookback period, its actually just average or maybe even below average compared to prior NY session opens. But prior NY session opens are not included in the lookback and thus ignored. This problem is the most visibly noticed when looking at the volume on a CME futures chart or some equivalent. In a 24 hour market, such as crypto, there are website's like skew can show you the volume disparity from time of day. This led me to believe that the traditional rVol calculation was insufficient. A better way to calculate it would be to compare the 9:30 am 30m bar today to the last week's worth of 9:30 am 30m bars. Then I could know whether today's volume at 9:30 am today is high or low based on prior 9:30 am bars. This seems to be a superior method on an intraday basis and is clearly superior in markets with irregular volume This led me to other problems, such as markets that are open for less than 24 hours and holiday hours on traditional market exchanges. How can I know that the script is accurately looking at the correct prior relevant bars. I've created and/or adapted solutions to all those problems and these calculations and code snippets thus have value that extend beyond this rVol script for other pinecoders. The Script This rVol script looks back at the bars of the same time period on the viewing timeframe. So, as we said, the last 9:30 bars. Averages those, then divides the: . The result is a percentage expressed as x.xxx. Thus 1.0 mean current volume is equal to average volume. Below 1.0 is below the average and above 1.0 is above the average. This information can be viewed on its own. But there are more levels of analysis added to it. Above the bars are signals that correlate to the "Better Volume Indicator" developed by, I believe, the folks at emini-watch and originally adapted to pinescript by LazyBear. The interpretation of these symbols are in a table on the right of the indicator. The volume bars can also be colored. The color is defined by the relationship between the average of the rVol outputs and the current volume. The "Average rVol" so to speak. The color coding is also defined by a legend in the table on the right. These can be researched by you to determine how to best interpret these signals. I originally got these ideas and solid details on how to use the analysis from a fellow out there, PlanTheTrade. I hope you find some value in the code and in the information that the indicator presents. And I'd like to thank the TradingView team for producing the most innovative and user friendly charting package on the market. (p.s. Better Volume is provides better information with a longer lookback value than the default imo) Credit for certain code sections and ideas is due to: LazyBear - Better Volume Grimmolf (From GitHub) - Logic for Loop rVol R4Rocket - The idea for my rVol 1 calculation And I can't find the guy who had the idea for the multiples of volume to the average. Tag him if you know him Final Note: I'd like to leave a couple of clues of my own for fellow seekers of trading infamy. Indicators: indicators are like anemometers (The things that measure windspeed). People talk bad about them all the time because they're "lagging." Well, you can't tell what the windspeed is unless the wind is blowing. anemometers are lagging indicators of wind. But forecasters still rely on them. You would use an indicator, which I would define as a instrument of measure, to tell you the windspeed of the markets. Conversely, when people talk positively about indicators they say "This one is great and this one is terrible." This is like a farmer saying "Shovels are great, but rakes are horrible." There are certain tools that have certain functions and every good tool has a purpose for a specific job. So the next time someone shares their opinion with you about indicators. Just smile and nod, realizing one day they'll learn... hopefully before they go broke. How to forecast: Prediction is accomplished by analyzing the behavior of instruments of measure to aggregate data (using your anemometer). The data is then assembled into a predictive model based on the measurements observed (a trading system). That predictive model is tested against reality for it's veracity (backtesting). If the model is predictive, you can optimize your decision making by creating parameter sets around the prediction that are synergistic with the implications of the prediction (risk, stop loss, target, scaling, pyramiding etc). <3
Pine Script®指標
由kurtsmock提供
74
PriceCatch Opensource CPRHi Friends & TradingView community. Greetings to you. Some traders like to use Central Pivot Range (CPR) in their chart for assessing price movement. It is usually used in combination with Pivot Levels. Calculating CPR is a simple matter. There a few CPR scripts in the Public Library, but have the code hidden. I thought there may many users who may want to know how CPR is calculated and study it for use in their own scripts. So, here is the CPR script with the code. Use it as you please. Note: CPR is plotted only on intra-day time-frames. The light magenta (band) range is current day CPR. The light blue (band) range is tomorrow's CPR projected for you today itself based on current day's price action and range. Queries / feedback welcome. All the best. PS: The script is developed to the best of my ability and as with all indicators, you have to decide if it might be useful to you when adding to your chart.
Pine Script®指標
由PriceCatch提供
Tic Tac Toe (For Fun)Hello All, I think all of you know the game "Tic Tac Toe" :) This time I tried to make this game, and also I tried to share an example to develop a game script in Pine. Just for fun ;) Tic Tac Toe Game Rules: 1. The game is played on a grid that's 3 squares by 3 squares. 2. You are "O", the computer is X. Players take turns putting their marks in empty squares. 3. if a player makes 3 of her marks in a row (up, down, across, or diagonally) the he is the winner. 4. When all 9 squares are full, the game is over (draw) So, how to play the game? - The player/you can play "O", meaning your mark is "O", so Xs for the script. please note that: The script plays with ONLY X - There is naming for all squears, A1, A2, A3, B1, B2, B3, C1, C2, C3. you will see all these squares in the options. - also You can set who will play first => "Human" or "Computer" if it's your turn to move then you will see "You Move" text, as seen in the following screenshot. for example you want to put "O" to "A1" then using options set A1 as O How the script play? it uses MinMax algorithm with constant depth = 4. And yes we don't have option to make recursive functions in Pine at the moment so I made four functions for each depth. this idea can be used in your scripts if you need such an algorithm. if you have no idea about MinMax algorithm you can find a lot of articles on the net :) The script plays its move automatically if its turn to play. you will just need to set the option that computer played (A1, C3, etc) if it's computer turn to play then it calculates and show the move it wants to play like "My Move : B3 <= X" then using options you need to set B3 as X Also it checks if the board is valid or not: I have tested it but if you see any bug let me know please Enjoy!
Pine Script®指標
由LonesomeTheBlue提供
29
Heikin Ashi Margin Scalping script for BitmexA script made for a lot of trades (scalping) and good solid profits on the Tested and it generates very attractive profits. Test it for yourself. - Made for BITCOIN / US DOLLAR PERPETUAL INVERSE SWAP CONTRACT XBTUSD on Bitmex. - Only 40% of these trades are profitable, but within this 40 percent, it catches all the spikes and lows. And therefore a lot more profit then loss. The most loss is generated at the moment BTC is falling still and there is not a lot of volatility. - I use it to create alerts and sent these to my bot, so i don't have to do manual trading. You can ask for access and try this strategy for yourself for 5 days. When you are convinced and want to have the script with alerts to be shared with you, I ask for a small donation of 0.02 BTC. This allows me to create other scripts and to improve this script. I only sell this script to 50 people, so that it remains exclusive.
Pine Script®策略
由Bobby-GeoTrader提供
32
[Autoview][BackTest]Dual MA Ribbons R0.12 by JustUncleLThis is an implementation of a strategy based on two MA Ribbons, a Fast Ribbon and a Slow Ribbon. This strategy can be used on Normal candlestick charts or Renko charts (if you are familiar with them). The strategy revolves around a pair of scripts: One to generate alerts signals for Autoview and one for Backtesting, to tune your settings. The risk management options are performed within the script to set SL(StopLoss), TP(TargetProfit), TSL(Trailing Stop Loss) and TTP (Trailing Target Profit). The only requirement for Autoview is to Buy and Sell as directed by this script, no complicated syntax is required. The Dual Ribbons are designed to capture the inferred behavior of traders and investors by using two groups of averages: > Traders MA Ribbon: Lower MA and Upper MA (Aqua=Uptrend, Blue=downtrend, Gray=Neutral), with center line Avg MA (Orange dotted line). > Investors MAs Ribbon: Lower MA and Upper MA (Green=Uptrend, Red=downtrend, Gray=Neutral), with center line Avg MA (Fuchsia dotted line). > Anchor time frame (0=current). This is the time frame that the MAs are calculated for. This way 60m MA Ribbons can be viewed on a 15 min chart to establish tighter Stop Loss conditions. Trade Management options: Option to specify Backtest start and end time. Trailing Stop, with Activate Level (as % of price) and Trailing Stop (as % of price) Target Profit Level, (as % of price) Stop Loss Level, (as % of price) BUY green triangles and SELL dark red triangles Trade Order closed colour coded Label: >> Dark Red = Stop Loss Hit >> Green = Target Profit Hit >> Purple = Trailing Stop Hit >> Orange = Opposite (Sell) Order Close Trade Management Indication: Trailing Stop Activate Price = Blue dotted line Trailing Stop Price = Fuschia solid stepping line Target Profit Price = Lime '+' line Stop Loss Price = Red '+' line Dealing With Renko Charts: If you choose to use Renko charts, make sure you have enabled the "IS This a RENKO Chart" option, (I have not so far found a way to Detect the type of chart that is running). If you want non-repainting Renko charts you MUST use TRADITIONAL Renko Bricks. This type of brick is fixed and will not change size. Also use Renko bricks with WICKS DISABLED. Wicks are not part of Renko, the whole idea of using Renko bricks is not to see the wick noise. Set you chart Time Frame to the lowest possible one that will build enough bricks to give a reasonable history, start at 1min TimeFrame. Renko bricks are not dependent on time, they represent a movement in price. But the chart candlestick data is used to create the bricks, so lower TF gives more accurate Brick creation. You want to size your bricks to 2/1000 of the pair price, so for ETHBTC the price is say 0.0805 then your Renko Brick size should be about 2*0.0805/1000 = 0.0002 (round up). You may find there is some slippage in value, but this can be accounted for in the Backtest by setting your commission a bit higher, for Binance for example I use 0.2% Special thanks goes to @CryptoRox for providing the initial Risk management Framework in his "How to automate this strategy for free using a chrome extension" example.
Pine Script®策略
由JustUncleL提供
14
alpha Renko intraday wave timeI was asked to share my experimental Renko intraday wave time. So here it is warts and all. The same for the rest - except the Weis cumulative volume. Renko wave time is in minutes. This script is strictly intraday and has not been played with extensively. You must use traditional Renko and set the script wave size to the same size as the Renko brick size. If you click on the sideways wishbone or "V" in the middle upper part of the chart you will get all of the scripts in this particular sandbox. After clicking the sideways wish bone click on "make it mine". You will then have the whole sandbox. The only published script is the Weis cumulative wave. The "Boys MAs" is supposed to be a script for daily charts and from within some kind of consolidation. In any case I am intrigued by some signals. You have a variety of sandbox options in the format section of the boys MAs. These codes are pretty rough with lots of abandoned lines of script.
Pine Script®指標
由jayy提供
11
IU Trailing Stop Loss MethodsThe 'IU Trailing Stop Loss Methods' it's a risk management tool which allows users to apply 12 trailing stop-loss (SL) methods for risk management of their trades and gives live alerts when the trailing Stop loss has hit. Below is a detailed explanation of each input and the working of the Script. Main Inputs: - bar_time: Specifies the date from which the trade begins and entry price will be the open of the first candle. - entry_type: Choose between 'Long' or 'Short' positions. - trailing_method: Select the trailing stop-loss method. Options include ATR, Parabolic SAR, Supertrend, Point/Pip based, Percentage, EMA, Highest/Lowest, Standard Deviation, and multiple target-based methods. - exit_after_close: If checked, exits the trade only after the candle closes. Optional Inputs: ATR Settings: - atr_Length: Length for the ATR calculation. - atr_factor: ATR multiplier for SL calculation. Parabolic SAR Settings: - start, increment, maximum: Parameters for the Parabolic SAR indicator. Supertrend Settings: - supertrend_Length, supertrend_factor: Length and factor for the Supertrend indicator. Point/Pip Based: - point_base: Set trailing SL in points/pips. Percentage Based: - percentage_base: Set SL as a percentage of entry price. EMA Settings: - ema_Length: Length for EMA calculation. Standard Deviation Settings: - std_Length, std_factor: Length and factor for standard deviation calculation. Highest/Lowest Settings: - highest_lowest_Length: Length for the highest/lowest SL calculation. Target-Based Inputs: - ATR, Point, Percentage, and Standard Deviation based target SL settings with customizable lengths and multipliers. Entry Logic: - Trades initiate based on the entry_type selected and the specified bar_time. - If Long is selected, a long trade is initiated when the conditions match, and vice versa for Short. Trailing Stop-Loss (SL) Methods Explained: The strategy dynamically adjusts stop-loss based on the chosen method. Each method has its calculation logic: - ATR: Stop-loss calculated using ATR multiplied by a user-defined factor. - Parabolic SAR: Uses the Parabolic SAR indicator for trailing stop-loss. - Supertrend: Utilizes the Supertrend indicator as the stop-loss line. - Point/Pip Based: Fixed point-based stop-loss. - Percentage Based: SL set as a percentage of entry price. - EMA: SL based on the Exponential Moving Average. - Highest/Lowest: Uses the highest high or lowest low over a specified period. - Standard Deviation: SL calculated using standard deviation. Exit Conditions: - If exit_after_close is enabled, the position will only close after the candle confirms the stop-loss hit. - If exit_after_close is disabled, the strategy will close the trade immediately when the SL is breached. Visualization: The script plots the chosen trailing stop-loss method on the chart for easy visualization. Target-Based Trailing SL Logic: - When a position is opened, the strategy calculates the initial stop-loss and progressively adjusts it as the price moves favorably. - Each SL adjustment is stored in an array for accurate tracking and visualization. Alerts and Labels: - When the Entry or trailing stop loss is hit this scripts draws a label and give alert to the user that trailing stop has been hit for the trade. Note - on the historical data The Script will show nothing if the entry and the exit has happened on the same candle, because we don't know what was hit first SL or TP (basically how the candle was formed on the lower timeframe). Summary: This script offers flexible trailing stop-loss options for traders who want dynamic risk management in their strategies. By offering multiple methods like ATR, SAR, Supertrend, and EMA, it caters to various trading styles and risk preferences.
Pine Script®指標
由Shivam_Mandrai提供
8
Simple COT ReportCOT Net Positions Indicator Author: © Munkhtur This indicator provides a comprehensive visualization of the Commitment of Traders (COT) report data, enabling traders to analyze market sentiment and positioning for key market participants. Key Features: Dashboard Display: Shows the net positions of Commercial, Noncommercial, and Nonreportable (Retail) traders. Dynamic Position Tracking: Highlights significant changes in long and short positions for all trader categories based on customizable percentage thresholds. COT Data Integration: Utilizes Legacy COT report data with clear segregation of long, short, and net positions. Visual Signals: Bullish and bearish trends are indicated with customizable colors for better chart visualization. Displays "open" and "close" position changes directly on the price candles for easier tracking. Flexible Configuration: Adjustable settings for dashboard location, text size, percentage thresholds, and color schemes. How to Use: Load the Script: Add the indicator to your Futures chart only by navigating to the TradingView indicators menu and selecting it from your saved scripts. Customize Settings: Dashboard: Enable or disable the dashboard, and set its position (Top Left, Top Right, etc.). Data on Candle: Turn on/off the visualization of COT data changes on price candles and define the percentage change threshold to focus on significant moves. Style Options: Customize bullish and bearish colors for better visual differentiation. Select Trader Group: Choose from Commercial, Noncommercial, or Nonreportable positions in the settings menu to analyze the specific group of market participants. Interpret Signals: Green bars indicate opening long positions or bullish sentiment. Red bars highlight opening short positions or bearish sentiment. Yellow and purple bars signify the closure of long and short positions, respectively. Use Cases: Identify market sentiment shifts by observing net position changes among different trader groups. Spot potential trend reversals based on COT data dynamics. Use as a complementary tool to confirm your existing trading strategies. Disclaimer: This indicator is a tool for educational and informational purposes only. Always combine it with your own analysis and risk management strategy when trading.
Pine Script®指標
由Munkhtur提供
1
Systematic Investment Tracker by Ceyhun Gonul### English Description **Systematic Investment Tracker with Enhanced Features** This script, titled **Systematic Investment Tracker with Enhanced Features**, is a TradingView tool designed to support systematic investments across different market conditions. It provides traders with two customizable investment strategies — **Continuous Buying** and **Declining Buying** — and includes advanced dynamic investment adjustment features for each. #### Detailed Explanation of Script Features and Originality 1. **Two Investment Strategies**: - **Continuous Buying**: This strategy performs purchases consistently at each interval, as set by the user, regardless of market price changes. It follows the principle of dollar-cost averaging, allowing users to build an investment position over time. - **Declining Buying**: Unlike Continuous Buying, this strategy triggers purchases only when the asset's price has declined from the previous interval's closing price. This approach helps users capitalize on lower price points, potentially improving average costs during downward trends. 2. **Dynamic Investment Adjustment**: - For both strategies, the script includes a **Dynamic Investment Adjustment** feature. If enabled, this feature increases the purchasing amount by 50% if the current price has fallen by a specific user-defined percentage relative to the previous price. This allows users to accumulate a larger position when the asset is declining, which may benefit long-term cost-averaging strategies. 3. **Customizable Time Frames**: - Users can specify a **start and end date** for investment, allowing them to restrict or backtest strategies within a specific timeframe. This feature is valuable for evaluating strategy performance over specific market cycles or historical periods. 4. **Graphical Indicators and Labels**: - The script provides graphical labels on the chart that display purchase points. These indicators help users visualize their investment entries based on the strategy selected. - A summary **performance label** is also displayed, providing real-time updates on the total amount spent, accumulated quantity, average cost, portfolio value, and profit percentage for each strategy. 5. **Language Support**: - The script includes English and Turkish language options. Users can toggle between these languages, allowing the summary label text and descriptions to be displayed in their preferred language. 6. **Performance Comparison Table**: - An optional **Performance Comparison Table** is available, offering a side-by-side analysis of net profit, total investment, and profit percentage for both strategies. This comparison table helps users assess which strategy has yielded better returns, providing clarity on each approach's effectiveness under the chosen parameters. #### How the Script Works and Its Uniqueness This closed-source script brings together two established investment strategies in a single, dynamic tool. By integrating continuous and declining purchase strategies with advanced settings for dynamic investment adjustment, the script offers a powerful, flexible tool for both passive and active investors. The design of this script provides unique benefits: - Enables automated, systematic investment tracking, allowing users to build positions gradually. - Empowers users to leverage declines through dynamic adjustments to optimize average cost over time. - Presents an easy-to-read performance label and table, enabling an efficient and transparent performance comparison for informed decision-making. --- ### Türkçe Açıklama **Gelişmiş Özellikli Sistematik Yatırım Takipçisi** **Gelişmiş Özellikli Sistematik Yatırım Takipçisi** adlı bu TradingView scripti, çeşitli piyasa koşullarında sistematik yatırım stratejilerini desteklemek üzere tasarlanmış bir araçtır. Script, kullanıcıya iki özelleştirilebilir yatırım stratejisi — **Sürekli Alım** ve **Düşen Alım** — ve her strateji için gelişmiş dinamik yatırım ayarlama seçenekleri sunar. #### Script Özelliklerinin Detaylı Açıklaması ve Özgünlük 1. **İki Yatırım Stratejisi**: - **Sürekli Alım**: Bu strateji, fiyat değişimlerine bakılmaksızın kullanıcının belirlediği her aralıkta sabit bir miktar yatırım yapar. Bu yaklaşım, uzun vadede pozisyonu kademeli olarak oluşturmak isteyenler için idealdir. - **Düşen Alım**: Sürekli Alım’ın aksine, bu strateji yalnızca fiyat bir önceki aralığın kapanış fiyatına göre düştüğünde alım yapar. Bu yöntem, yatırımcıların daha düşük fiyatlardan alım yaparak ortalama maliyeti potansiyel olarak iyileştirmelerine yardımcı olur. 2. **Dinamik Yatırım Ayarlaması**: - Her iki strateji için de **Dinamik Yatırım Ayarlaması** özelliği bulunmaktadır. Bu özellik aktif edildiğinde, mevcut fiyatın bir önceki fiyata göre kullanıcı tarafından belirlenen bir yüzde oranında düşmesi durumunda alım miktarını %50 artırır. Bu durum, uzun vadede maliyet ortalaması stratejilerine katkıda bulunur. 3. **Özelleştirilebilir Tarih Aralığı**: - Kullanıcılar, yatırımı belirli bir tarih aralığında sınırlandırmak veya test etmek için bir **başlangıç ve bitiş tarihi** belirleyebilir. Bu özellik, strateji performansını geçmiş piyasa döngüleri veya belirli dönemlerde değerlendirmek için kullanışlıdır. 4. **Grafiksel İşaretleyiciler ve Etiketler**: - Script, grafik üzerinde alım noktalarını gösteren işaretleyiciler sağlar. Bu görsel göstergeler, kullanıcıların seçilen stratejiye göre yatırım girişlerini görselleştirmesine yardımcı olur. - Ayrıca, her strateji için harcanan toplam tutar, biriken miktar, ortalama maliyet, portföy değeri ve kâr yüzdesi gibi bilgileri gerçek zamanlı olarak gösteren bir **performans etiketi** sunar. 5. **Dil Desteği**: - Script, İngilizce ve Türkçe dillerini desteklemektedir. Kullanıcılar, performans etiketi metninin ve açıklamalarının tercih ettikleri dilde görüntülenmesi için dil seçimini yapabilir. 6. **Performans Karşılaştırma Tablosu**: - İsteğe bağlı olarak kullanılabilen bir **Performans Karşılaştırma Tablosu**, her iki strateji için net kâr, toplam yatırım ve kâr yüzdesi gibi bilgileri yan yana analiz eder. Bu tablo, kullanıcıların hangi stratejinin daha yüksek getiri sağladığını değerlendirmesine yardımcı olur. #### Scriptin Çalışma Prensibi ve Özgünlüğü Bu script, iki yatırım stratejisini gelişmiş bir araçta birleştirir. Sürekli ve düşen fiyatlara dayalı alım stratejilerini dinamik yatırım ayarlama özelliğiyle entegre ederek yatırımcılar için güçlü ve esnek bir çözüm sunar. Script’in tasarımı aşağıdaki benzersiz faydaları sağlamaktadır: - Otomatik, sistematik yatırım takibi yaparak kullanıcıların pozisyonlarını kademeli olarak oluşturmalarına olanak tanır. - Dinamik ayarlama ile düşüşlerden yararlanarak zaman içinde ortalama maliyeti optimize etme olanağı sağlar. - Her iki stratejinin performansını basit ve anlaşılır bir şekilde karşılaştıran etiket ve tablo ile verimli bir performans değerlendirmesi sunar.
Pine Script®指標
由markoramius提供
Sessions [UkutaLabs]█ OVERVIEW Sessions is a trading toolkit that displays the different trading sessions on your chart during a trading day. By default, Sessions displays the four standard trading sessions; New York, Tokyo, London, and Sydney. Each of the four sessions can be toggled, and the Sessions indicator is completely customizable, allowing users to define their own sessions to be generated by the script. The aim of this script is to improve the trading experience of users by automatically displaying information about each default or custom session to the user. █ USAGE This script will automatically detect and label different market sessions. By default, the script will identify the four standard trading sessions, but each of these can be toggled off in the settings. However, users are not limited to these four trading sessions and have the ability to define their own sessions to be identified by the script. When a session begins, the script will automatically start outlining the market data of that session, including the high and low of the period that is represented by the session. If the market is within two or more sessions at the same time, then each session will be treated individually and will overlap with each other. The sessions will be identified as a colored box surrounding the market data of the period that it represents, and a label will be displayed above the box to identify the session that it represents. The label, color and period of each session is completely customizable. The user can also adjust all sessions at once to account for timezones in the settings. █ SETTINGS Session 1 • Session 1: Determines whether or not this session will be drawn by the script. • A string field to determine the name of the session that will be displayed above the session range. • Two time fields representing the start and finish of the session. • A color field to determine the color of the range and label. Session 2 • Session 2: Determines whether or not this session will be drawn by the script. • A string field to determine the name of the session that will be displayed above the session range. • Two time fields representing the start and finish of the session. • A color field to determine the color of the range and label. Session 3 • Session 3: Determines whether or not this session will be drawn by the script. • A string field to determine the name of the session that will be displayed above the session range. • Two time fields representing the start and finish of the session. • A color field to determine the color of the range and label. Session 4 • Session 4: Determines whether or not this session will be drawn by the script. • A string field to determine the name of the session that will be displayed above the session range. • Two time fields representing the start and finish of the session. • A color field to determine the color of the range and label. Time Zones • UTC +/-: Determines the offset of each session. Enter - before the number to represent a negative offset.
Pine Script®指標
由UkutaLabs提供
1
chrono_utilsLibrary "chrono_utils" 📝 Description Collection of objects and common functions that are related to datetime windows session days and time ranges. The main purpose of this library is to handle time-related functionality and make it easy to reason about a future bar checking if it will be part of a predefined session and/or inside a datetime window. All existing session functionality I found in the documentation e.g. "not na(time(timeframe, session, timezone))" are not suitable for strategy scripts, since the execution of the orders is delayed by one bar, due to the script execution happening at the bar close. Moreover, a history operator with a negative value that looks forward is not allowed in any pinescript expression. So, a prediction for the next bar using the bars_back argument of "time()"" and "time_close()" was necessary. Thus, I created this library to overcome this small but very important limitation. In the meantime, I added useful functionality to handle session-based behavior. An interesting utility that emerged from this development is data anomaly detection where a comparison between the prediction and the actual value is happening. If those two values are different then a data inconsistency happens between the prediction bar and the actual bar (probably due to a holiday, half session day, a timezone change etc..) 🤔 How to Guide To use the functionality this library provides in your script you have to import it first! Copy the import statement of the latest release by pressing the copy button below and then paste it into your script. Give a short name to this library so you can refer to it later on. The import statement should look like this: import jason5480/chrono_utils/2 as chr To check if a future bar will be inside a window first of all you have to initialize a DateTimeWindow object. A code example is the following: var dateTimeWindow = chr.DateTimeWindow.new().init(fromDateTime = timestamp('01 Jan 2023 00:00'), toDateTime = timestamp('01 Jan 2024 00:00')) Then you have to "ask" the dateTimeWindow if the future bar defined by an offset (default is 1 that corresponds th the next bar), will be inside that window: // Filter bars outside of the datetime window bool dateFilterApproval = dateTimeWindow.is_bar_included() You can visualize the result by drawing the background of the bars that are outside the given window: bgcolor(color = dateFilterApproval ? na : color.new(color.fuchsia, 90), offset = 1, title = 'Datetime Window Filter') In the same way, you can "ask" the Session if the future bar defined by an offset it will be inside that session. First of all, you should initialize a Session object. A code example is the following: var sess = chr.Session.new().from_sess_string(sess = '0800-1700:23456', refTimezone = 'UTC') Then check if the given bar defined by the offset (default is 1 that corresponds th the next bar), will be inside the session like that: // Filter bars outside the sessions bool sessionFilterApproval = view.sess.is_bar_included() You can visualize the result by drawing the background of the bars that are outside the given session: bgcolor(color = sessionFilterApproval ? na : color.new(color.red, 90), offset = 1, title = 'Session Filter') In case you want to visualize multiple session ranges you can create a SessionView object like that: var view = SessionView.new().init(SessionDays.new().from_sess_string('2345'), array.from(SessionTimeRange.new().from_sess_string('0800-1600'), SessionTimeRange.new().from_sess_string('1300-2200')), array.from('London', 'New York'), array.from(color.blue, color.orange)) and then call the draw method of the SessionView object like that: view.draw() 🏋️‍♂️ Please refer to the "EXAMPLE DATETIME WINDOW FILTER" and "EXAMPLE SESSION FILTER" regions of the script for more advanced code examples of how to utilize the full potential of this library, including user input settings and advanced visualization! ⚠️ Caveats As I mentioned in the description there are some cases that the prediction of the next bar is not accurate. A wrong prediction will affect the outcome of the filtering. The main reasons this could happen are the following: Public holidays when the market is closed Half trading days usually before public holidays Change in the daylight saving time (DST) A data anomaly of the chart, where there are missing and/or inconsistent data. A bug in this library (Please report by PM sending the symbol, timeframe, and settings) Special thanks to @robbatt and @skinra for the constructive feedback 🏆. Without them, the exposed API of this library would be very lengthy and complicated to use. Thanks to them, now the user of this library will be able to get the most, with only a few lines of code!
Pine Script®腳本庫
由jason5480提供
6
MTFT Reversal Lines, TheStrat Suite (5of5)Multi Time Frame Tools Multi Time Frame Tools (MTFT) is a suite of scripts aimed to establish a standard timeframe-based color scheme. This can be utilized to overlay different timeframes calculations/values over a single timeframe. As one example, this would allow to observe the 5-month moving average, 5-week moving average, and 5-day moving average overlaid over each other. This would allow to study a chart, get accustomed to the color scheme and study all these at the same time much easier. All indicators calculated using the below specific timeframes as input, will always use the color scheme outlined below. This is to get you in habit of recognizing the different timeframes overlaid in top of each other. These can be personalized. Longer TF analysis. Yearly - Black Semi-Annual - Yellow Quarterly - White Monthly - Maroon Weekly - Royal Blue Daily - Lime Shorter TF analysis. 4 hour - Fuchsia 1 hour - Orange 30 min - Red 15 min - Brown 10 min - Purple 5 min - Lilac All color coordination is able to be modified in either the “Inputs” or “Style” section. If you need to make changes, make sure to select “Save as Default” on the bottom right of the settings menu. Recommended Chart Color Layout I played around with color coordination a lot. The final product was what worked best for me. I personally use the following chart settings to accent all available TF colors. -> Click on the settings wheel on your chart. -> Click on “Appearance”. Background - Solid -> On the top row pick the 6th color from the left. Vert Grid Lines and Horz Grid Lines -> On the top row pick the 7th color from the left. You may of course change these and the indicator line colors as you like. Adding indicator to Chart -> Open the TradingView “Indicators & Strategies” library, the icon has “ƒx”. -> All premium scripts will be located under “Invite-Only Scripts” -> Click indicator to add to your chart. MTFT TheStrat Suite (5 Scripts) Rob Smith is the creator of ‘TheStrat’ trading strategy. For ‘TheStrat’ I have put together a suite of 5 premium scripts that combined will offer people interested in learning ‘TheStrat’ a cleaner learning process. For 2 of the 5 scripts specifically, the MTFT approach of overlaying multiple longer timeframes(TF) over a shorter TF selected as a display cannot be utilized. The other 2 scripts will have full MTFT functionality and they are my personal favorite. I will be providing very basic info to utilize this script; it is up to you to dive deep into learning this strategy. I am not an expert with the tool or a financial advisor. As with all aspects of life, I recommend you research, learn, discern and practice extensively in order to become a master. 1. MTFT Patterns Pro/Noob 2. MTFT Full Time Frame Continuity Table 3. MTFT Last HML wOpen 4. MTFT Actionable Signal Targets *5. MTFT Reversal Lines MTFT Reversal Lines, TheStrat Suite (5of5) This script will plot the line at the point that the reversal was formed for multiple timeframes. Often times price retraces to these points before making more explosive moves in continuation of the reversal direction. The script has the following features. Six user selected time frames per script instance can be enabled/disabled. Timeframes include: Yearly(Y), Semi-annually(S), Quarterly(Q), Monthly(M), Weekly(W), Daily(D), 4 hour, 1 hour, 30 min, 15 min, 10 min, and 5 min. Image below shows the Weekly TF selected, and only the W, Q, M, and W are enabled. I’ve included some comments on basic observations. 2. Auto hide lower timeframe calculations. Auto Hide feature will hide smaller TF calculations when a larger timeframe is selected as the display TF. Example, when the Daily timeframe candlestick selected the 4 hour and smaller calculations are hidden because they produce irrelevant results relative to the selected timeframe. If a lower TF is selected such as the 30 min candlestick, the previously hidden timeframes are now displayed. This allows easier study as you change between displayed timeframes. This script works best in conjunction with ‘MTFT Last HML Band wOpen’. In the image below I have the W candlestick selected, along with the Q HML Lines, and the Q Reversal Line shown. It shows you a clearer picture of how price moves on a TheStrat continuation CS and after a TheStrat reversal point is made. This lets you break into the fine details of what happened inside Quarter 1, 2022 and after the reversal point was formed. IMPORTANT NOTE for TradingView admin: One of the lessons I would consider most important in attaining clarity regarding trading, is “TheStrat” by Rob Smith. His lesson on “actionable signals” is something that can be applied to any strategy. For this reason, I am including “MTFT TheStrat Patterns Pro” script in all images that will depict confluence for a better trade selection. Example using TheStrat Pro MTFT with this indicator. Look for a “TheStrat actionable signal” or a “TheStrat Reversal signal” on a smaller timeframe that has an instance of this indicator on a larger timeframe calculation that is in range of the candlestick that formed your actionable signal. This means that the indicators plot you are observing must be above the low and below the high of the candlestick that is the actionable signal/reversal signal. Image below shows what this would look like with this indicator. The Image below shows what this would look like with this indicator. The selected candlestick is the 3-day, it shows a 2U-1-potential 2D Reversal pattern and the Quarter Reversal Down line in range. This actionable signal is meant to be played for SHORTS. If the low is breached, you would enter a SHORT position from the low of the inside candlestick. For targets you would look at the previous pivots, for this example all targets were hit. This won’t always play out so nice and clean, but given that there is so many stocks and so many signals this is just a thought to improve the quality of the signal as it has extra confluence.
Pine Script®指標
由Multi_TF_Tools提供
ProfitBee59 ProProfitBee59 Pro for TradingView helps you do tedious works on your technical charts. *It does CC59 counting and prints out a positive or negative number on each price bar. When the counting arrives at -9 or +9, it creates support and resistance (SNR) levels on the chart. *It detects a Mom and Baby (MNB) pair of price bars where the left bar has higher high and lower low prices compared to those of the right bar. When a Mom and Baby pair is detected, Mommy head (high price of Mommy bar) and Mommy toe (low price of Mommy bar) levels are drawn on the chart. *It calculates and plots a volume-weighted-average-price (VWAP) line on the chart with purple color for declining value and white color for rising value. *It detects and draws a supply trend line of negative slope that links between two local maximum points on the chart. *It detects and draws a demand trend line of positive slope that links between two local minimum points on the chart. *It shows arrows and bells based on various configurable conditions on the chart. ------------------------------ How to install the script: ------------------------------ *Go to the bottom of this page and click on "Add to Favorite Scripts". *Remove older version of the script by clicking on the "X" button behind the indicator line at the top left corner of the chart window. *Open a new chart at and click on the "Indicators" tab. *Click on the "Favorites" tab and choose "ProfitBee59 Pro". *Right click anywhere on the graph, choose "Color Theme", the select "Dark". *Right click anywhere on the graph, choose "Settings". *In "Symbol" tab, set "Precision" to 1/100 for stock price or 1/100000 for Forex and set "Time Zone" to your local time. *In "Scales" tab, check "Symbol Name Label" and "Indicator Last Value Label". *In "Events" tab, check "Show Dividends on Chart", "Show Splits on Chart" and "Show Earnings on Chart". *At the bottom of settings window, click on "Template", "Save As...", then name this theme of graph setting for future call up such as "Stock pb59pro" or "Forex pb59pro" or "Crypto pb59pro". *Click OK. ========================================== ProfitBee59 Pro for TradingView (pb59pro) is locked and protected. Please ***do not*** ask for access in the comment section. Use the link below to obtain access to this indicator. ==========================================
Pine Script®指標
由nimit.chomnawang提供
Pinescript - Standard Array Functions Library by RRBStandard Array Functions Library by RagingRocketBull 2021 Version 1.0 This script provides a library of every standard Pinescript array function for live testing with all supported array types. You can find the full list of supported standard array functions below. There are several libraries: - Common String Functions Library - Common Array Functions Library - Standard Array Functions Library Features: - Supports all standard array functions (30+) with all possible array types* (* - except array.new* functions and label, line array types) - Live Output for all/selected functions based on User Input. Test any function for possible errors you may encounter before using in script. - Output filters: show errors, hide all excluded and show only allowed functions using a list of function names - Console customization options: set custom text size, color, page length, line spacing Notes: - uses Pinescript v3 Compatibility Framework - uses Common String Functions Library - has to be a separate script to reduce the number of local scopes in Common Array Function Library, there's no way to merge these scripts into a single library. - lets you live test all standard array functions for errors. If you see an error - change params in UI - array types that are not supported by certain functions and producing a compilation error were disabled with "error" showing up as result - if you see "Loop too long" error - hide/unhide or reattach the script - doesn't use pagination, a single str contains all output - for most array functions to work (except push), an array must be defined with at least 1 pre-existing dummy element 0. - array.slice and array.fill require from_index < to_index otherwise error - array.join only supports string arrays, and delimiter must be a const string, can't be var/input. Use join_any_array to join any array type into string. You can also use tostring() to join int, float arrays. - array.sort only supports int, float arrays. Use sort_any_array from the Common Array Function Library to sort any array type. - array.sort only sorts values, doesn't preserve indexes. Use sort_any_array from the Common Array Function Library to sort any array while preserving indexes. - array.concat appends string arrays in reverse order, other array types are appended correctly - array.covariance requires 2 int, float arrays of the same size - tostring(flag) works only for internal bool vars, flag expression can't depend on any inputs of any type, use bool_to_str instead - you can't create an if/function that returns var type value/array - compiler uses strict types and doesn't allow that - however you can assign array of any type to another array of any type creating an arr pointer of invalid type that must be reassigned to a matching array type before used in any expression to prevent error - source_array and create_any_array2 use this loophole to return an int_arr pointer of a var type array - this works for all array types defined with/without var keyword. This doesn't work for string arrays defined with var keyword for some reason - you can't do this with var type vars, this can be done only with var type arrays because they are pointers passed by reference, while vars are the actual values passed by value. - wrapper functions solve the problem of returning var array types. This is the only way of doing it when the top level arr type is undefined. - you can only pass a var type value/array param to a function if all functions inside support every type - otherwise error - alternatively values of every type must be passed simultaneously and processed separately by corresponding if branches/functions supporting these particular types returning a common single result type - get_var_types solves this problem by generating a list of dummy values of every possible type including the source type, allowing a single valid branch to execute without error - examples of functions supporting all array types: array.size, array.get, array.push. Examples of functions with limited type support: array.sort, array.join, array.max, tostring - unlike var params/global vars, you can modify array params and global arrays directly from inside functions using standard array functions, but you can't use := (it only works for local arrays) - inside function always work with array.copy to prevent accidental array modification - you can't compare arrays - there's no na equivalent for arrays, na(arr) doesn't work P.S. A wide array of skills calls for an even wider array of responsibilities List of functions: - array.avg(arr) - array.clear(arr) - array.concat(arr1, arr2) - array.copy(arr) - array.covariance(arr1, arr2) - array.fill(arr, value, index_from, index_to) - array.get(arr, index) - array.includes(arr, value) - array.indexof(arr, value) - array.insert(arr, index, value) - array.join(arr, delimiter) - array.lastindexof(arr, value) - array.max(arr) - array.median(arr) - array.min(arr) - array.mode(arr) - array.pop(arr) - array.push(arr, value) - array.range(arr) - array.remove(arr, index) - array.reverse(arr) - array.set(arr, index, value) - array.shift(arr) - array.size(arr) - array.slice(arr, index_from, index_to) - array.sort(arr, order) - array.standardize() - array.stdev(arr) - array.sum(arr) - array.unshift(arr, value) - array.variance(arr)
Pine Script®指標
由RagingRocketBull提供
2